home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 2003 August / MW 8 2003 CD1.iso / Inside Macworld / Product News / gimp-1.2.4.sit / gimp-1.2.4 / app / channel.c < prev    next >
Encoding:
C/C++ Source or Header  |  2003-01-04  |  41.6 KB  |  1,783 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 2 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17.  */
  18.  
  19. #include "config.h"
  20.  
  21. #include <stdlib.h>
  22. #include <string.h>
  23.  
  24. #include <gtk/gtk.h>
  25.  
  26. #include "apptypes.h"
  27.  
  28. #include "appenv.h"
  29. #include "channel.h"
  30. #include "drawable.h"
  31. #include "gdisplay.h"
  32. #include "gimage_mask.h"
  33. #include "layer.h"
  34. #include "paint_funcs.h"
  35. #include "parasitelist.h"
  36. #include "temp_buf.h"
  37. #include "undo.h"
  38. #include "gimpsignal.h"
  39. #include "gimppreviewcache.h"
  40.  
  41. #include "channel_pvt.h"
  42. #include "tile.h"
  43.  
  44. #include "gimplut.h"
  45. #include "lut_funcs.h"
  46.  
  47. #include "libgimp/gimpmath.h"
  48.  
  49. #include "libgimp/gimpintl.h"
  50.  
  51.  
  52. enum {
  53.   REMOVED,
  54.   LAST_SIGNAL
  55. };
  56.  
  57. static void gimp_channel_class_init (GimpChannelClass *klass);
  58. static void gimp_channel_init       (GimpChannel      *channel);
  59. static void gimp_channel_destroy    (GtkObject        *object);
  60.  
  61. static TempBuf * channel_preview_private (Channel *channel,
  62.                       gint     width,
  63.                       gint     height);
  64.  
  65. static guint channel_signals[LAST_SIGNAL] = { 0 };
  66.  
  67. static GimpDrawableClass *parent_class = NULL;
  68.  
  69. GtkType
  70. gimp_channel_get_type ()
  71. {
  72.   static GtkType channel_type = 0;
  73.  
  74.   if (!channel_type)
  75.     {
  76.       GtkTypeInfo channel_info =
  77.       {
  78.     "GimpChannel",
  79.     sizeof (GimpChannel),
  80.     sizeof (GimpChannelClass),
  81.     (GtkClassInitFunc) gimp_channel_class_init,
  82.     (GtkObjectInitFunc) gimp_channel_init,
  83.         /* reserved_1 */ NULL,
  84.     /* reserved_2 */ NULL,
  85.     (GtkClassInitFunc) NULL,
  86.       };
  87.  
  88.       channel_type = gtk_type_unique (gimp_drawable_get_type (), &channel_info);
  89.     }
  90.  
  91.   return channel_type;
  92. }
  93.  
  94. static void
  95. gimp_channel_class_init (GimpChannelClass *class)
  96. {
  97.   GtkObjectClass *object_class;
  98.  
  99.   object_class = (GtkObjectClass*) class;
  100.   parent_class = gtk_type_class (gimp_drawable_get_type ());
  101.  
  102.   channel_signals[REMOVED] =
  103.       gimp_signal_new ("removed",
  104.                0, object_class->type, 0, gimp_sigtype_void);
  105.  
  106.   gtk_object_class_add_signals (object_class, channel_signals, LAST_SIGNAL);
  107.  
  108.   object_class->destroy = gimp_channel_destroy;
  109. }
  110.  
  111. static void
  112. gimp_channel_init (GimpChannel *channel)
  113. {
  114. }
  115.  
  116. /**************************/
  117. /*  Function definitions  */
  118. /**************************/
  119.  
  120. static void
  121. channel_validate (TileManager *tm,
  122.           Tile        *tile)
  123. {
  124.   /*  Set the contents of the tile to empty  */
  125.   memset (tile_data_pointer (tile, 0, 0), 
  126.       TRANSPARENT_OPACITY, tile_size (tile));
  127. }
  128.  
  129. Channel *
  130. channel_new (GimpImage *gimage,
  131.          gint       width,
  132.          gint       height,
  133.          gchar     *name,
  134.          gint       opacity,
  135.          guchar    *col)
  136. {
  137.   Channel * channel;
  138.   gint i;
  139.  
  140.   channel = gtk_type_new (gimp_channel_get_type ());
  141.  
  142.   gimp_drawable_configure (GIMP_DRAWABLE (channel), 
  143.                gimage, width, height, GRAY_GIMAGE, name);
  144.  
  145.   /*  set the channel color and opacity  */
  146.   for (i = 0; i < 3; i++)
  147.     channel->col[i] = col[i];
  148.  
  149.   channel->opacity     = opacity;
  150.   channel->show_masked = TRUE;
  151.  
  152.   /*  selection mask variables  */
  153.   channel->empty          = TRUE;
  154.   channel->segs_in        = NULL;
  155.   channel->segs_out       = NULL;
  156.   channel->num_segs_in    = 0;
  157.   channel->num_segs_out   = 0;
  158.   channel->bounds_known   = TRUE;
  159.   channel->boundary_known = TRUE;
  160.   channel->x1             = 0;
  161.   channel->y1             = 0;
  162.   channel->x2             = width;
  163.   channel->y2             = height;
  164.  
  165.   return channel;
  166. }
  167.  
  168. Channel *
  169. channel_ref (Channel *channel)
  170. {
  171.   gtk_object_ref  (GTK_OBJECT (channel));
  172.   gtk_object_sink (GTK_OBJECT (channel));
  173.  
  174.   return channel;
  175. }
  176.  
  177. void
  178. channel_unref (Channel *channel)
  179. {
  180.   gtk_object_unref (GTK_OBJECT (channel));
  181. }
  182.  
  183. Channel *
  184. channel_copy (Channel *channel)
  185. {
  186.   gchar *channel_name;
  187.   Channel *new_channel;
  188.   PixelRegion srcPR, destPR;
  189.   gchar *ext;
  190.   gint number;
  191.   gchar *name;
  192.   gint len;
  193.  
  194.   /*  formulate the new channel name  */
  195.   name = channel_get_name (channel);
  196.   ext = strrchr (name, '#');
  197.   len = strlen (_("copy"));
  198.   if ((strlen (name) >= len &&
  199.        strcmp (&name[strlen (name) - len], _("copy")) == 0) ||
  200.       (ext && (number = atoi (ext + 1)) > 0 && 
  201.        ((int)(log10 (number) + 1)) == strlen (ext + 1)))
  202.     /* don't have redundant "copy"s */
  203.     channel_name = g_strdup (name);
  204.   else
  205.     channel_name = g_strdup_printf (_("%s copy"), name);
  206.  
  207.   /*  allocate a new channel object  */
  208.   new_channel = channel_new (GIMP_DRAWABLE (channel)->gimage, 
  209.                  GIMP_DRAWABLE (channel)->width, 
  210.                  GIMP_DRAWABLE (channel)->height, 
  211.                  channel_name, channel->opacity, channel->col);
  212.   GIMP_DRAWABLE (new_channel)->visible = GIMP_DRAWABLE (channel)->visible;
  213.   new_channel->show_masked = channel->show_masked;
  214.  
  215.   /*  copy the contents across channels  */
  216.   pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles, 0, 0, 
  217.              GIMP_DRAWABLE (channel)->width, 
  218.              GIMP_DRAWABLE (channel)->height, FALSE);
  219.   pixel_region_init (&destPR, GIMP_DRAWABLE (new_channel)->tiles,
  220.              0, 0,
  221.              GIMP_DRAWABLE (channel)->width,
  222.              GIMP_DRAWABLE (channel)->height, TRUE);
  223.   copy_region (&srcPR, &destPR);
  224.  
  225.   /* copy the parasites */
  226.   GIMP_DRAWABLE (new_channel)->parasites 
  227.     = parasite_list_copy (GIMP_DRAWABLE (channel)->parasites);
  228.  
  229.   /*  free up the channel_name memory  */
  230.   g_free (channel_name);
  231.  
  232.   return new_channel;
  233. }
  234.  
  235. void
  236. channel_set_name (Channel *channel,
  237.           gchar   *name)
  238. {
  239.   gimp_drawable_set_name (GIMP_DRAWABLE (channel), name);
  240. }
  241.  
  242. gchar *
  243. channel_get_name (Channel *channel)
  244. {
  245.   return gimp_drawable_get_name (GIMP_DRAWABLE (channel));
  246. }
  247.  
  248. void 
  249. channel_set_color (Channel *channel,
  250.            guchar  *color)
  251. {
  252.   gint i;
  253.  
  254.   if (color)
  255.     {  
  256.       for (i = 0; i < 3; i++)
  257.     channel->col[i] = color[i];
  258.     }
  259. }
  260.  
  261. guchar *
  262. channel_get_color (Channel *channel)
  263. {
  264.   return (GIMP_CHANNEL (channel)->col); 
  265. }
  266.  
  267. int
  268. channel_get_opacity (Channel *channel)
  269. { 
  270.   return channel->opacity;
  271. }
  272.  
  273. void 
  274. channel_set_opacity (Channel *channel,
  275.              gint     opacity)
  276. {
  277.   if (opacity >=0 && opacity <= 100)
  278.     channel->opacity = (gint) (opacity * 255) / 100;
  279. }
  280.  
  281. Channel *
  282. channel_get_ID (gint ID)
  283. {
  284.   GimpDrawable *drawable;
  285.  
  286.   drawable = drawable_get_ID (ID);
  287.   if (drawable && GIMP_IS_CHANNEL (drawable)) 
  288.     return GIMP_CHANNEL (drawable);
  289.   else
  290.     return NULL;
  291. }
  292.  
  293. void
  294. channel_delete (Channel *channel)
  295. {
  296.   /*  Channels are normally deleted by removing them from the associated
  297.       image. The only case where channel_delete() is useful is if you want
  298.       to remove a floating channel object that has not been added to an
  299.       image yet. We use gtk_object_sink() for this reason here.
  300.    */
  301.   gtk_object_sink (GTK_OBJECT (channel));
  302. }
  303.  
  304. static void
  305. gimp_channel_destroy (GtkObject *object)
  306. {
  307.   GimpChannel *channel;
  308.  
  309.   g_return_if_fail (object != NULL);
  310.   g_return_if_fail (GIMP_IS_CHANNEL (object));
  311.  
  312.   channel = GIMP_CHANNEL (object);
  313.  
  314.   /* free the segments?  */
  315.   if (channel->segs_in)
  316.     g_free (channel->segs_in);
  317.   if (channel->segs_out)
  318.     g_free (channel->segs_out);
  319.  
  320.   if (GTK_OBJECT_CLASS (parent_class)->destroy)
  321.     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
  322.   
  323. }
  324.  
  325. /* The removed signal is sent out when the channel is no longer
  326.  * associcated with an image.  It's needed because channels aren't
  327.  * destroyed immediately, but kept around for undo purposes.  Connect
  328.  * to the removed signal to update bits of UI that are tied to a
  329.  * particular layer. */
  330. void
  331. channel_removed (Channel  *channel,
  332.          gpointer  data)
  333. {
  334.   g_return_if_fail (channel != NULL);
  335.   g_return_if_fail (GIMP_IS_CHANNEL (channel));
  336.  
  337.   gtk_signal_emit (GTK_OBJECT (channel), channel_signals[REMOVED]);
  338. }
  339.  
  340.  
  341. void
  342. channel_scale (Channel *channel,
  343.            gint     new_width,
  344.            gint     new_height)
  345. {
  346.   PixelRegion srcPR, destPR;
  347.   TileManager *new_tiles;
  348.  
  349.   if (new_width == 0 || new_height == 0)
  350.     return;
  351.  
  352.   /*  Update the old channel position  */
  353.   drawable_update (GIMP_DRAWABLE (channel),
  354.            0, 0,
  355.            GIMP_DRAWABLE (channel)->width,
  356.            GIMP_DRAWABLE (channel)->height);
  357.  
  358.   /*  Configure the pixel regions  */
  359.   pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
  360.              0, 0,
  361.              GIMP_DRAWABLE (channel)->width,
  362.              GIMP_DRAWABLE (channel)->height, FALSE);
  363.  
  364.   /*  Allocate the new channel, configure dest region  */
  365.   new_tiles = tile_manager_new (new_width, new_height, 1);
  366.   pixel_region_init (&destPR, new_tiles, 0, 0, new_width, new_height, TRUE);
  367.  
  368.   /*  Add an alpha channel  */
  369.   scale_region (&srcPR, &destPR);
  370.  
  371.   /*  Push the channel on the undo stack  */
  372.   undo_push_channel_mod (GIMP_DRAWABLE (channel)->gimage, channel);
  373.  
  374.   /*  Configure the new channel  */
  375.   GIMP_DRAWABLE (channel)->tiles = new_tiles;
  376.   GIMP_DRAWABLE (channel)->width = new_width;
  377.   GIMP_DRAWABLE (channel)->height = new_height;
  378.  
  379.   /*  bounds are now unknown  */
  380.   channel->bounds_known = FALSE;
  381.  
  382.   /*  Update the new channel position  */
  383.   drawable_update (GIMP_DRAWABLE (channel),
  384.            0, 0,
  385.            GIMP_DRAWABLE (channel)->width,
  386.            GIMP_DRAWABLE (channel)->height);
  387. }
  388.  
  389. void
  390. channel_resize (Channel *channel,
  391.         gint     new_width,
  392.         gint     new_height,
  393.         gint     offx,
  394.         gint     offy)
  395. {
  396.   PixelRegion srcPR, destPR;
  397.   TileManager *new_tiles;
  398.   guchar bg = 0;
  399.   gint clear;
  400.   gint w, h;
  401.   gint x1, y1, x2, y2;
  402.  
  403.   if (!new_width || !new_height)
  404.     return;
  405.  
  406.   x1 = CLAMP (offx, 0, new_width);
  407.   y1 = CLAMP (offy, 0, new_height);
  408.   x2 = CLAMP ((offx + GIMP_DRAWABLE (channel)->width), 0, new_width);
  409.   y2 = CLAMP ((offy + GIMP_DRAWABLE (channel)->height), 0, new_height);
  410.   w = x2 - x1;
  411.   h = y2 - y1;
  412.  
  413.   if (offx > 0)
  414.     {
  415.       x1 = 0;
  416.       x2 = offx;
  417.     }
  418.   else
  419.     {
  420.       x1 = -offx;
  421.       x2 = 0;
  422.     }
  423.  
  424.   if (offy > 0)
  425.     {
  426.       y1 = 0;
  427.       y2 = offy;
  428.     }
  429.   else
  430.     {
  431.       y1 = -offy;
  432.       y2 = 0;
  433.     }
  434.  
  435.   /*  Update the old channel position  */
  436.   drawable_update (GIMP_DRAWABLE (channel),
  437.            0, 0,
  438.            GIMP_DRAWABLE (channel)->width,
  439.            GIMP_DRAWABLE (channel)->height);
  440.  
  441.   /*  Configure the pixel regions  */
  442.   pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
  443.              x1, y1, w, h, FALSE);
  444.  
  445.   /*  Determine whether the new channel needs to be initially cleared  */
  446.   if ((new_width  > GIMP_DRAWABLE (channel)->width) ||
  447.       (new_height > GIMP_DRAWABLE (channel)->height) ||
  448.       (x2 || y2))
  449.     clear = TRUE;
  450.   else
  451.     clear = FALSE;
  452.  
  453.   /*  Allocate the new channel, configure dest region  */
  454.   new_tiles = tile_manager_new (new_width, new_height, 1);
  455.  
  456.   /*  Set to black (empty--for selections)  */
  457.   if (clear)
  458.     {
  459.       pixel_region_init (&destPR, new_tiles, 0, 0, new_width, new_height, TRUE);
  460.       color_region (&destPR, &bg);
  461.     }
  462.  
  463.   /*  copy from the old to the new  */
  464.   pixel_region_init (&destPR, new_tiles, x2, y2, w, h, TRUE);
  465.   if (w && h)
  466.     copy_region (&srcPR, &destPR);
  467.  
  468.   /*  Push the channel on the undo stack  */
  469.   undo_push_channel_mod (GIMP_DRAWABLE (channel)->gimage, channel);
  470.  
  471.   /*  Configure the new channel  */
  472.   GIMP_DRAWABLE (channel)->tiles  = new_tiles;
  473.   GIMP_DRAWABLE (channel)->width  = new_width;
  474.   GIMP_DRAWABLE (channel)->height = new_height;
  475.  
  476.   /*  bounds are now unknown  */
  477.   channel->bounds_known = FALSE;
  478.  
  479.   /*  update the new channel area  */
  480.   drawable_update (GIMP_DRAWABLE (channel),
  481.            0, 0,
  482.            GIMP_DRAWABLE (channel)->width,
  483.            GIMP_DRAWABLE (channel)->height);
  484. }
  485.  
  486. void            
  487. channel_update (Channel *channel)
  488. {
  489.   drawable_update (GIMP_DRAWABLE (channel),
  490.            0, 0,
  491.            GIMP_DRAWABLE (channel)->width,
  492.            GIMP_DRAWABLE (channel)->height);
  493.   gdisplays_flush ();
  494. }
  495.  
  496. /**********************/
  497. /*  access functions  */
  498. /**********************/
  499.  
  500. gboolean
  501. channel_toggle_visibility (Channel *channel)
  502. {
  503.   GIMP_DRAWABLE (channel)->visible = !GIMP_DRAWABLE (channel)->visible;
  504.  
  505.   return GIMP_DRAWABLE (channel)->visible;
  506. }
  507.  
  508. TempBuf *
  509. channel_preview (Channel *channel,
  510.          gint     width,
  511.          gint     height)
  512. {
  513.   /* Ok prime the cache with a large preview if the cache is invalid */
  514.   if (! GIMP_DRAWABLE (channel)->preview_valid &&
  515.       width  <= PREVIEW_CACHE_PRIME_WIDTH    &&
  516.       height <= PREVIEW_CACHE_PRIME_HEIGHT   &&
  517.       GIMP_DRAWABLE (channel)->gimage          &&
  518.       GIMP_DRAWABLE (channel)->gimage->width  > PREVIEW_CACHE_PRIME_WIDTH   &&
  519.       GIMP_DRAWABLE (channel)->gimage->height > PREVIEW_CACHE_PRIME_HEIGHT)
  520.     {
  521.       TempBuf * tb = channel_preview_private (channel,
  522.                           PREVIEW_CACHE_PRIME_WIDTH,
  523.                           PREVIEW_CACHE_PRIME_HEIGHT);
  524.       
  525.       /* Save the 2nd call */
  526.       if (width  == PREVIEW_CACHE_PRIME_WIDTH &&
  527.       height == PREVIEW_CACHE_PRIME_HEIGHT)
  528.     return tb;
  529.     }
  530.  
  531.   /* Second call - should NOT visit the tile cache...*/
  532.   return channel_preview_private (channel, width, height);
  533. }
  534.  
  535. static TempBuf *
  536. channel_preview_private (Channel *channel,
  537.              gint     width,
  538.              gint     height)
  539. {
  540.   MaskBuf     *preview_buf;
  541.   PixelRegion  srcPR;
  542.   PixelRegion  destPR;
  543.   gint         subsample;
  544.   TempBuf     *ret_buf;
  545.  
  546.   g_return_val_if_fail (channel != NULL, NULL);
  547.   g_return_val_if_fail (GIMP_IS_CHANNEL (channel), NULL);
  548.   
  549.   /*  The easy way  */
  550.   if (GIMP_DRAWABLE (channel)->preview_valid &&
  551.       (ret_buf =
  552.        gimp_preview_cache_get (& (GIMP_DRAWABLE (channel)->preview_cache),
  553.                    width, height)))
  554.     return ret_buf;
  555.   /*  The hard way  */
  556.   else
  557.     {
  558.       /*  calculate 'acceptable' subsample  */
  559.       subsample = 1;
  560.       if (width < 1) width = 1;
  561.       if (height < 1) height = 1;
  562.       while ((width  * (subsample + 1) * 2 < GIMP_DRAWABLE (channel)->width) &&
  563.          (height * (subsample + 1) * 2 < GIMP_DRAWABLE (channel)->height))
  564.     subsample = subsample + 1;
  565.  
  566.       pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
  567.              0, 0,
  568.              GIMP_DRAWABLE (channel)->width,
  569.              GIMP_DRAWABLE (channel)->height, FALSE);
  570.  
  571.       preview_buf = mask_buf_new (width, height);
  572.       destPR.bytes     = 1;
  573.       destPR.x         = 0;
  574.       destPR.y         = 0;
  575.       destPR.w         = width;
  576.       destPR.h         = height;
  577.       destPR.rowstride = width;
  578.       destPR.data      = mask_buf_data (preview_buf);
  579.  
  580.       subsample_region (&srcPR, &destPR, subsample);
  581.  
  582.       if (!GIMP_DRAWABLE (channel)->preview_valid)
  583.     gimp_preview_cache_invalidate (&(GIMP_DRAWABLE(channel)->preview_cache));
  584.  
  585.       GIMP_DRAWABLE (channel)->preview_valid = TRUE;
  586.       gimp_preview_cache_add (&(GIMP_DRAWABLE (channel)->preview_cache),
  587.                   preview_buf);
  588.       return preview_buf;
  589.     }
  590. }
  591.  
  592. void
  593. channel_invalidate_previews (GimpImage* gimage)
  594. {
  595.   GSList * tmp;
  596.   Channel * channel;
  597.  
  598.   g_return_if_fail (gimage != NULL);
  599.  
  600.   tmp = gimage->channels;
  601.  
  602.   while (tmp)
  603.     {
  604.       channel = (Channel *) tmp->data;
  605.       gimp_drawable_invalidate_preview (GIMP_DRAWABLE (channel), TRUE);
  606.       tmp = g_slist_next (tmp);
  607.     }
  608. }
  609.  
  610. Tattoo
  611. channel_get_tattoo (const Channel *channel)
  612. {
  613.   return (gimp_drawable_get_tattoo (GIMP_DRAWABLE (channel)));
  614. }
  615.  
  616. void
  617. channel_set_tattoo (const Channel *channel, 
  618.             Tattoo         value)
  619. {
  620.   gimp_drawable_set_tattoo (GIMP_DRAWABLE (channel), value);
  621. }
  622.  
  623. /******************************/
  624. /*  selection mask functions  */
  625. /******************************/
  626.  
  627. Channel *
  628. channel_new_mask (GimpImage *gimage,
  629.           gint       width,
  630.           gint       height)
  631. {
  632.   guchar black[3] = {0, 0, 0};
  633.   Channel *new_channel;
  634.  
  635.   /*  Create the new channel  */
  636.   new_channel = channel_new (gimage, width, height,
  637.                  _("Selection Mask"), 127, black);
  638.  
  639.   /*  Set the validate procedure  */
  640.   tile_manager_set_validate_proc (GIMP_DRAWABLE (new_channel)->tiles,
  641.                   channel_validate);
  642.  
  643.   return new_channel;
  644. }
  645.  
  646. gboolean
  647. channel_boundary (Channel   *mask,
  648.           BoundSeg **segs_in,
  649.           BoundSeg **segs_out,
  650.           gint      *num_segs_in,
  651.           gint      *num_segs_out,
  652.           gint       x1,
  653.           gint       y1,
  654.           gint       x2,
  655.           gint       y2)
  656. {
  657.   gint x3, y3, x4, y4;
  658.   PixelRegion bPR;
  659.  
  660.   if (! mask->boundary_known)
  661.     {
  662.       /* free the out of date boundary segments */
  663.       if (mask->segs_in)
  664.     g_free (mask->segs_in);
  665.       if (mask->segs_out)
  666.     g_free (mask->segs_out);
  667.  
  668.       if (channel_bounds (mask, &x3, &y3, &x4, &y4))
  669.     {
  670.       pixel_region_init (&bPR, GIMP_DRAWABLE (mask)->tiles,
  671.                  x3, y3, (x4 - x3), (y4 - y3), FALSE);
  672.       mask->segs_out = find_mask_boundary (&bPR, &mask->num_segs_out,
  673.                            IgnoreBounds,
  674.                            x1, y1,
  675.                            x2, y2);
  676.       x1 = MAX (x1, x3);
  677.       y1 = MAX (y1, y3);
  678.       x2 = MIN (x2, x4);
  679.       y2 = MIN (y2, y4);
  680.  
  681.       if (x2 > x1 && y2 > y1)
  682.         {
  683.           pixel_region_init (&bPR, GIMP_DRAWABLE (mask)->tiles,
  684.                  0, 0,
  685.                  GIMP_DRAWABLE (mask)->width,
  686.                  GIMP_DRAWABLE (mask)->height, FALSE);
  687.           mask->segs_in =  find_mask_boundary (&bPR, &mask->num_segs_in,
  688.                            WithinBounds,
  689.                            x1, y1,
  690.                            x2, y2);
  691.         }
  692.       else
  693.         {
  694.           mask->segs_in     = NULL;
  695.           mask->num_segs_in = 0;
  696.         }
  697.     }
  698.       else
  699.     {
  700.       mask->segs_in      = NULL;
  701.       mask->segs_out     = NULL;
  702.       mask->num_segs_in  = 0;
  703.       mask->num_segs_out = 0;
  704.     }
  705.       mask->boundary_known = TRUE;
  706.     }
  707.  
  708.   *segs_in      = mask->segs_in;
  709.   *segs_out     = mask->segs_out;
  710.   *num_segs_in  = mask->num_segs_in;
  711.   *num_segs_out = mask->num_segs_out;
  712.  
  713.   return TRUE;
  714. }
  715.  
  716. gint
  717. channel_value (Channel *mask,
  718.            gint     x,
  719.            gint     y)
  720. {
  721.   Tile *tile;
  722.   gint val;
  723.  
  724.   /*  Some checks to cut back on unnecessary work  */
  725.   if (mask->bounds_known)
  726.     {
  727.       if (mask->empty)
  728.     return 0;
  729.       else if (x < mask->x1 || x >= mask->x2 || y < mask->y1 || y >= mask->y2)
  730.     return 0;
  731.     }
  732.   else
  733.     {
  734.       if (x < 0 || x >= GIMP_DRAWABLE (mask)->width ||
  735.       y < 0 || y >= GIMP_DRAWABLE (mask)->height)
  736.     return 0;
  737.     }
  738.  
  739.   tile = tile_manager_get_tile (GIMP_DRAWABLE (mask)->tiles, x, y, TRUE, FALSE);
  740.   val = *(guchar *) (tile_data_pointer (tile, x % TILE_WIDTH, y % TILE_HEIGHT));
  741.   tile_release (tile, FALSE);
  742.  
  743.   return val;
  744. }
  745.  
  746. gboolean
  747. channel_bounds (Channel *mask,
  748.         gint    *x1,
  749.         gint    *y1,
  750.         gint    *x2,
  751.         gint    *y2)
  752. {
  753.   PixelRegion maskPR;
  754.   guchar *data, *data1;
  755.   gint x, y;
  756.   gint ex, ey;
  757.   gint tx1, tx2, ty1, ty2;
  758.   gint minx, maxx;
  759.   gpointer pr;
  760.  
  761.   /*  if the mask's bounds have already been reliably calculated...  */
  762.   if (mask->bounds_known)
  763.     {
  764.       *x1 = mask->x1;
  765.       *y1 = mask->y1;
  766.       *x2 = mask->x2;
  767.       *y2 = mask->y2;
  768.  
  769.       return !mask->empty;
  770.     }
  771.  
  772.   /*  go through and calculate the bounds  */
  773.   tx1 = GIMP_DRAWABLE (mask)->width;
  774.   ty1 = GIMP_DRAWABLE (mask)->height;
  775.   tx2 = 0;
  776.   ty2 = 0;
  777.  
  778.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  779.              0, 0,
  780.              GIMP_DRAWABLE (mask)->width,
  781.              GIMP_DRAWABLE (mask)->height, FALSE);
  782.   for (pr = pixel_regions_register (1, &maskPR);
  783.        pr != NULL;
  784.        pr = pixel_regions_process (pr))
  785.     {
  786.       data1 = data = maskPR.data;
  787.       ex = maskPR.x + maskPR.w;
  788.       ey = maskPR.y + maskPR.h;
  789.       /* only check the pixels if this tile is not fully within the currently
  790.      computed bounds */
  791.       if (maskPR.x < tx1 || ex > tx2 ||
  792.       maskPR.y < ty1 || ey > ty2)
  793.         {
  794.       /* Check upper left and lower right corners to see if we can
  795.          avoid checking the rest of the pixels in this tile */
  796.       if (data[0] && data[maskPR.rowstride*(maskPR.h - 1) + maskPR.w - 1])
  797.       {
  798.         if (maskPR.x < tx1)
  799.           tx1 = maskPR.x;
  800.         if (ex > tx2)
  801.           tx2 = ex;
  802.         if (maskPR.y < ty1)
  803.           ty1 = maskPR.y;
  804.         if (ey > ty2)
  805.           ty2 = ey;
  806.       }
  807.       else
  808.         for (y = maskPR.y; y < ey; y++, data1 += maskPR.rowstride)
  809.         {
  810.           for (x = maskPR.x, data = data1; x < ex; x++, data++)
  811.         if (*data)
  812.         {
  813.           minx = x;
  814.           maxx = x;
  815.           for (; x < ex; x++, data++)
  816.             if (*data)
  817.               maxx = x;
  818.           if (minx < tx1)
  819.             tx1 = minx;
  820.           if (maxx > tx2)
  821.             tx2 = maxx;
  822.           if (y < ty1)
  823.             ty1 = y;
  824.           if (y > ty2)
  825.             ty2 = y;
  826.           }
  827.         }
  828.     }
  829.     }
  830.  
  831.   tx2 = CLAMP (tx2 + 1, 0, GIMP_DRAWABLE (mask)->width);
  832.   ty2 = CLAMP (ty2 + 1, 0, GIMP_DRAWABLE (mask)->height);
  833.  
  834.   if (tx1 == GIMP_DRAWABLE (mask)->width && ty1 == GIMP_DRAWABLE (mask)->height)
  835.     {
  836.       mask->empty = TRUE;
  837.       mask->x1    = 0;
  838.       mask->y1    = 0;
  839.       mask->x2    = GIMP_DRAWABLE (mask)->width;
  840.       mask->y2    = GIMP_DRAWABLE (mask)->height;
  841.     }
  842.   else
  843.     {
  844.       mask->empty = FALSE;
  845.       mask->x1    = tx1;
  846.       mask->y1    = ty1;
  847.       mask->x2    = tx2;
  848.       mask->y2    = ty2;
  849.     }
  850.   mask->bounds_known = TRUE;
  851.  
  852.   *x1 = tx1;
  853.   *x2 = tx2;
  854.   *y1 = ty1;
  855.   *y2 = ty2;
  856.  
  857.   return !mask->empty;
  858. }
  859.  
  860. gboolean
  861. channel_is_empty (Channel *mask)
  862. {
  863.   PixelRegion maskPR;
  864.   guchar * data;
  865.   gint x, y;
  866.   gpointer pr;
  867.  
  868.   if (mask->bounds_known)
  869.     return mask->empty;
  870.  
  871.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  872.              0, 0,
  873.              GIMP_DRAWABLE (mask)->width,
  874.              GIMP_DRAWABLE (mask)->height, FALSE);
  875.   for (pr = pixel_regions_register (1, &maskPR);
  876.        pr != NULL;
  877.        pr = pixel_regions_process (pr))
  878.     {
  879.       /*  check if any pixel in the mask is non-zero  */
  880.       data = maskPR.data;
  881.       for (y = 0; y < maskPR.h; y++)
  882.     for (x = 0; x < maskPR.w; x++)
  883.       if (*data++)
  884.         {
  885.           pixel_regions_process_stop (pr);
  886.           return FALSE;
  887.         }
  888.     }
  889.  
  890.   /*  The mask is empty, meaning we can set the bounds as known  */
  891.   if (mask->segs_in)
  892.     g_free (mask->segs_in);
  893.   if (mask->segs_out)
  894.     g_free (mask->segs_out);
  895.  
  896.   mask->empty          = TRUE;
  897.   mask->segs_in        = NULL;
  898.   mask->segs_out       = NULL;
  899.   mask->num_segs_in    = 0;
  900.   mask->num_segs_out   = 0;
  901.   mask->bounds_known   = TRUE;
  902.   mask->boundary_known = TRUE;
  903.   mask->x1             = 0;
  904.   mask->y1             = 0;
  905.   mask->x2             = GIMP_DRAWABLE (mask)->width;
  906.   mask->y2             = GIMP_DRAWABLE (mask)->height;
  907.  
  908.   return TRUE;
  909. }
  910.  
  911. void
  912. channel_add_segment (Channel *mask,
  913.              gint     x,
  914.              gint     y,
  915.              gint     width,
  916.              gint     value)
  917. {
  918.   PixelRegion maskPR;
  919.   guchar *data;
  920.   gint val;
  921.   gint x2;
  922.   gpointer pr;
  923.  
  924.   /*  check horizontal extents...  */
  925.   x2 = x + width;
  926.   if (x2 < 0) x2 = 0;
  927.   if (x2 > GIMP_DRAWABLE (mask)->width) x2 = GIMP_DRAWABLE (mask)->width;
  928.   if (x < 0) x = 0;
  929.   if (x > GIMP_DRAWABLE (mask)->width) x = GIMP_DRAWABLE (mask)->width;
  930.   width = x2 - x;
  931.   if (!width) return;
  932.  
  933.   if (y < 0 || y > GIMP_DRAWABLE (mask)->height)
  934.     return;
  935.  
  936.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  937.              x, y, width, 1, TRUE);
  938.   for (pr = pixel_regions_register (1, &maskPR);
  939.        pr != NULL;
  940.        pr = pixel_regions_process (pr))
  941.     {
  942.       data = maskPR.data;
  943.       width = maskPR.w;
  944.       while (width--)
  945.     {
  946.       val = *data + value;
  947.       if (val > 255)
  948.         val = 255;
  949.       *data++ = val;
  950.     }
  951.     }
  952. }
  953.  
  954. void
  955. channel_sub_segment (Channel *mask,
  956.              gint     x,
  957.              gint     y,
  958.              gint     width,
  959.              gint     value)
  960. {
  961.   PixelRegion maskPR;
  962.   guchar *data;
  963.   gint val;
  964.   gint x2;
  965.   gpointer pr;
  966.  
  967.   /*  check horizontal extents...  */
  968.   x2 = x + width;
  969.   if (x2 < 0) x2 = 0;
  970.   if (x2 > GIMP_DRAWABLE (mask)->width) x2 = GIMP_DRAWABLE (mask)->width;
  971.   if (x < 0) x = 0;
  972.   if (x > GIMP_DRAWABLE (mask)->width) x = GIMP_DRAWABLE (mask)->width;
  973.   width = x2 - x;
  974.   if (!width) return;
  975.  
  976.   if (y < 0 || y > GIMP_DRAWABLE (mask)->height)
  977.     return;
  978.  
  979.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles, x, y, width, 1, TRUE);
  980.   for (pr = pixel_regions_register (1, &maskPR);
  981.        pr != NULL;
  982.        pr = pixel_regions_process (pr))
  983.     {
  984.       data = maskPR.data;
  985.       width = maskPR.w;
  986.       while (width--)
  987.     {
  988.       val = *data - value;
  989.       if (val < 0)
  990.         val = 0;
  991.       *data++ = val;
  992.     }
  993.     }
  994. }
  995.  
  996. void
  997. channel_combine_rect (Channel    *mask,
  998.               ChannelOps  op,
  999.               gint        x,
  1000.               gint        y,
  1001.               gint        w,
  1002.               gint        h)
  1003. {
  1004.   gint x2, y2;
  1005.   PixelRegion maskPR;
  1006.   guchar color;
  1007.  
  1008.   y2 = y + h;
  1009.   x2 = x + w;
  1010.  
  1011.   x  = CLAMP (x,  0, GIMP_DRAWABLE (mask)->width);
  1012.   y  = CLAMP (y,  0, GIMP_DRAWABLE (mask)->height);
  1013.   x2 = CLAMP (x2, 0, GIMP_DRAWABLE (mask)->width);
  1014.   y2 = CLAMP (y2, 0, GIMP_DRAWABLE (mask)->height);
  1015.  
  1016.   if (x2 - x <= 0 || y2 - y <= 0)
  1017.     return;
  1018.  
  1019.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  1020.              x, y, x2 - x, y2 - y, TRUE);
  1021.   if (op == ADD  || op == REPLACE)
  1022.     color = 255;
  1023.   else
  1024.     color = 0;
  1025.   color_region (&maskPR, &color);
  1026.  
  1027.   /*  Determine new boundary  */
  1028.   if (mask->bounds_known && (op == ADD) && !mask->empty)
  1029.     {
  1030.       if (x < mask->x1)
  1031.     mask->x1 = x;
  1032.       if (y < mask->y1)
  1033.     mask->y1 = y;
  1034.       if ((x + w) > mask->x2)
  1035.     mask->x2 = (x + w);
  1036.       if ((y + h) > mask->y2)
  1037.     mask->y2 = (y + h);
  1038.     }
  1039.   else if (op == REPLACE || mask->empty)
  1040.     {
  1041.       mask->empty = FALSE;
  1042.       mask->x1 = x;
  1043.       mask->y1 = y;
  1044.       mask->x2 = x + w;
  1045.       mask->y2 = y + h;
  1046.     }
  1047.   else
  1048.     mask->bounds_known = FALSE;
  1049.  
  1050.   mask->x1 = CLAMP (mask->x1, 0, GIMP_DRAWABLE (mask)->width);
  1051.   mask->y1 = CLAMP (mask->y1, 0, GIMP_DRAWABLE (mask)->height);
  1052.   mask->x2 = CLAMP (mask->x2, 0, GIMP_DRAWABLE (mask)->width);
  1053.   mask->y2 = CLAMP (mask->y2, 0, GIMP_DRAWABLE (mask)->height);
  1054. }
  1055.  
  1056. void
  1057. channel_combine_ellipse (Channel    *mask,
  1058.              ChannelOps  op,
  1059.              gint        x,
  1060.              gint        y,
  1061.              gint        w,
  1062.              gint        h,
  1063.              gboolean    antialias)
  1064. {
  1065.   gint i, j;
  1066.   gint x0, x1, x2;
  1067.   gint val, last;
  1068.   gfloat a_sqr, b_sqr, aob_sqr;
  1069.   gfloat w_sqr, h_sqr;
  1070.   gfloat y_sqr;
  1071.   gfloat t0, t1;
  1072.   gfloat r;
  1073.   gfloat cx, cy;
  1074.   gfloat rad;
  1075.   gfloat dist;
  1076.  
  1077.   if (!w || !h)
  1078.     return;
  1079.  
  1080.   a_sqr = (w * w / 4.0);
  1081.   b_sqr = (h * h / 4.0);
  1082.   aob_sqr = a_sqr / b_sqr;
  1083.  
  1084.   cx = x + w / 2.0;
  1085.   cy = y + h / 2.0;
  1086.  
  1087.   for (i = y; i < (y + h); i++)
  1088.     {
  1089.       if (i >= 0 && i < GIMP_DRAWABLE (mask)->height)
  1090.     {
  1091.       /*  Non-antialiased code  */
  1092.       if (!antialias)
  1093.         {
  1094.           y_sqr = (i + 0.5 - cy) * (i + 0.5 - cy);
  1095.           rad = sqrt (a_sqr - a_sqr * y_sqr / (double) b_sqr);
  1096.           x1 = ROUND (cx - rad);
  1097.           x2 = ROUND (cx + rad);
  1098.  
  1099.           switch (op)
  1100.         {
  1101.         case ADD: case REPLACE:
  1102.           channel_add_segment (mask, x1, i, (x2 - x1), 255);
  1103.           break;
  1104.         case SUB :
  1105.           channel_sub_segment (mask, x1, i, (x2 - x1), 255);
  1106.           break;
  1107.         default:
  1108.           g_warning ("Only ADD, REPLACE and SUB are valid for channel_combine!");
  1109.           break;
  1110.         }
  1111.         }
  1112.       /*  antialiasing  */
  1113.       else
  1114.         {
  1115.           x0 = x;
  1116.           last = 0;
  1117.           h_sqr = (i + 0.5 - cy) * (i + 0.5 - cy);
  1118.           for (j = x; j < (x + w); j++)
  1119.         {
  1120.           w_sqr = (j + 0.5 - cx) * (j + 0.5 - cx);
  1121.  
  1122.           if (h_sqr != 0)
  1123.             {
  1124.               t0 = w_sqr / h_sqr;
  1125.               t1 = a_sqr / (t0 + aob_sqr);
  1126.               r = sqrt (t1 + t0 * t1);
  1127.               rad = sqrt (w_sqr + h_sqr);
  1128.               dist = rad - r;
  1129.             }
  1130.           else
  1131.             dist = -1.0;
  1132.  
  1133.           if (dist < -0.5)
  1134.             val = 255;
  1135.           else if (dist < 0.5)
  1136.             val = (int) (255 * (1 - (dist + 0.5)));
  1137.           else
  1138.             val = 0;
  1139.           
  1140.           if (last != val && last)
  1141.             {
  1142.               switch (op)
  1143.             {
  1144.             case ADD: case REPLACE:
  1145.               channel_add_segment (mask, x0, i, j - x0, last);
  1146.               break;
  1147.             case SUB:
  1148.               channel_sub_segment (mask, x0, i, j - x0, last);
  1149.               break;
  1150.             default:
  1151.               g_warning ("Only ADD, REPLACE and SUB are valid for channel_combine!");
  1152.               break;
  1153.             }
  1154.             }
  1155.  
  1156.           if (last != val)
  1157.             {
  1158.               x0 = j;
  1159.               last = val;
  1160.               /* because we are symetric accross the y axis we can
  1161.              skip ahead a bit if we are inside the ellipse*/
  1162.               if (val == 255 && j < cx)
  1163.             j = cx + (cx - j) - 1;
  1164.             }
  1165.         }
  1166.  
  1167.           if (last)
  1168.         {
  1169.           if (op == ADD || op == REPLACE)
  1170.             channel_add_segment (mask, x0, i, j - x0, last);
  1171.           else if (op == SUB)
  1172.             channel_sub_segment (mask, x0, i, j - x0, last);
  1173.           else
  1174.             g_warning ("Only ADD, REPLACE and SUB are valid for channel_combine!");
  1175.         }
  1176.         }
  1177.  
  1178.     }
  1179.     }
  1180.  
  1181.   /*  Determine new boundary  */
  1182.   if (mask->bounds_known && (op == ADD) && !mask->empty)
  1183.     {
  1184.       if (x < mask->x1)
  1185.     mask->x1 = x;
  1186.       if (y < mask->y1)
  1187.     mask->y1 = y;
  1188.       if ((x + w) > mask->x2)
  1189.     mask->x2 = (x + w);
  1190.       if ((y + h) > mask->y2)
  1191.     mask->y2 = (y + h);
  1192.     }
  1193.   else if (op == REPLACE || mask->empty)
  1194.     {
  1195.       mask->empty = FALSE;
  1196.       mask->x1 = x;
  1197.       mask->y1 = y;
  1198.       mask->x2 = x + w;
  1199.       mask->y2 = y + h;
  1200.     }
  1201.   else
  1202.     mask->bounds_known = FALSE;
  1203.  
  1204.   mask->x1 = CLAMP (mask->x1, 0, GIMP_DRAWABLE (mask)->width);
  1205.   mask->y1 = CLAMP (mask->y1, 0, GIMP_DRAWABLE (mask)->height);
  1206.   mask->x2 = CLAMP (mask->x2, 0, GIMP_DRAWABLE (mask)->width);
  1207.   mask->y2 = CLAMP (mask->y2, 0, GIMP_DRAWABLE (mask)->height);
  1208. }
  1209.  
  1210. static void
  1211. channel_combine_sub_region_add (void        *unused,
  1212.                 PixelRegion *srcPR,
  1213.                 PixelRegion *destPR)
  1214. {
  1215.   guchar *src, *dest;
  1216.   gint x, y, val;
  1217.  
  1218.   src  = srcPR->data;
  1219.   dest = destPR->data;
  1220.  
  1221.   for (y = 0; y < srcPR->h; y++)
  1222.     {
  1223.       for (x = 0; x < srcPR->w; x++)
  1224.     {
  1225.       val = dest[x] + src[x];
  1226.       if (val > 255)
  1227.         dest[x] = 255;
  1228.       else
  1229.         dest[x] = val;
  1230.     }
  1231.       src  += srcPR->rowstride;
  1232.       dest += destPR->rowstride;
  1233.     }
  1234. }
  1235.  
  1236. static void
  1237. channel_combine_sub_region_sub (void        *unused,
  1238.                 PixelRegion *srcPR,
  1239.                 PixelRegion *destPR)
  1240. {
  1241.   guchar *src, *dest;
  1242.   gint x, y;
  1243.  
  1244.   src  = srcPR->data;
  1245.   dest = destPR->data;
  1246.  
  1247.   for (y = 0; y < srcPR->h; y++)
  1248.     {
  1249.       for (x = 0; x < srcPR->w; x++)
  1250.     {
  1251.       if (src[x] > dest[x])
  1252.         dest[x] = 0;
  1253.       else
  1254.         dest[x]-= src[x];
  1255.     }
  1256.       src  += srcPR->rowstride;
  1257.       dest += destPR->rowstride;
  1258.     }
  1259. }
  1260.  
  1261. static void
  1262. channel_combine_sub_region_intersect (void        *unused,
  1263.                       PixelRegion *srcPR,
  1264.                       PixelRegion *destPR)
  1265. {
  1266.   guchar *src, *dest;
  1267.   gint x, y;
  1268.  
  1269.   src  = srcPR->data;
  1270.   dest = destPR->data;
  1271.  
  1272.   for (y = 0; y < srcPR->h; y++)
  1273.     {
  1274.       for (x = 0; x < srcPR->w; x++)
  1275.     {
  1276.       dest[x] = MIN (dest[x], src[x]);
  1277.     }
  1278.       src  += srcPR->rowstride;
  1279.       dest += destPR->rowstride;
  1280.   }
  1281. }
  1282.  
  1283. void
  1284. channel_combine_mask (Channel    *mask,
  1285.               Channel    *add_on,
  1286.               ChannelOps  op,
  1287.               gint        off_x,
  1288.               gint        off_y)
  1289. {
  1290.   PixelRegion srcPR, destPR;
  1291.   gint x1, y1, x2, y2;
  1292.   gint w, h;
  1293.  
  1294.   x1 = CLAMP (off_x, 0, GIMP_DRAWABLE (mask)->width);
  1295.   y1 = CLAMP (off_y, 0, GIMP_DRAWABLE (mask)->height);
  1296.   x2 = CLAMP (off_x + GIMP_DRAWABLE (add_on)->width, 0,
  1297.           GIMP_DRAWABLE (mask)->width);
  1298.   y2 = CLAMP (off_y + GIMP_DRAWABLE (add_on)->height, 0,
  1299.           GIMP_DRAWABLE (mask)->height);
  1300.  
  1301.   w = (x2 - x1);
  1302.   h = (y2 - y1);
  1303.  
  1304.   pixel_region_init (&srcPR, GIMP_DRAWABLE (add_on)->tiles,
  1305.              (x1 - off_x), (y1 - off_y), w, h, FALSE);
  1306.   pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles, x1, y1, w, h, TRUE);
  1307.  
  1308.   switch (op)
  1309.     {
  1310.     case ADD: case REPLACE:
  1311.       pixel_regions_process_parallel ((p_func) channel_combine_sub_region_add,
  1312.                       NULL, 2, &srcPR, &destPR);
  1313.       break;
  1314.     case SUB:
  1315.       pixel_regions_process_parallel ((p_func) channel_combine_sub_region_sub,
  1316.                       NULL, 2, &srcPR, &destPR);
  1317.       break;
  1318.     case INTERSECT:
  1319.       pixel_regions_process_parallel ((p_func)
  1320.                       channel_combine_sub_region_intersect,
  1321.                       NULL, 2, &srcPR, &destPR);
  1322.       break;
  1323.     default:
  1324.       g_message ("Error: unknown opperation type in channel_combine_mask\n");
  1325.       break;
  1326.     }
  1327.   mask->bounds_known = FALSE;
  1328. }
  1329.  
  1330. void
  1331. channel_feather (Channel    *input,
  1332.          Channel    *output,
  1333.          gdouble     radius_x,
  1334.          gdouble     radius_y,
  1335.          ChannelOps  op,
  1336.          gint        off_x,
  1337.          gint        off_y)
  1338. {
  1339.   gint x1, y1, x2, y2;
  1340.   PixelRegion srcPR;
  1341.  
  1342.   x1 = CLAMP (off_x, 0, GIMP_DRAWABLE (output)->width);
  1343.   y1 = CLAMP (off_y, 0, GIMP_DRAWABLE (output)->height);
  1344.   x2 = CLAMP (off_x + GIMP_DRAWABLE (input)->width, 0,
  1345.           GIMP_DRAWABLE (output)->width);
  1346.   y2 = CLAMP (off_y + GIMP_DRAWABLE (input)->height, 0,
  1347.           GIMP_DRAWABLE (output)->height);
  1348.  
  1349.   pixel_region_init (&srcPR, GIMP_DRAWABLE (input)->tiles,
  1350.              (x1 - off_x), (y1 - off_y), (x2 - x1), (y2 - y1), FALSE);
  1351.   gaussian_blur_region (&srcPR, radius_x, radius_y);
  1352.  
  1353.   if (input != output) 
  1354.     channel_combine_mask (output, input, op, off_x, off_y);
  1355.  
  1356.   output->bounds_known = FALSE;
  1357. }
  1358.  
  1359. void
  1360. channel_push_undo (Channel *mask)
  1361. {
  1362.   gint x1, y1, x2, y2;
  1363.   MaskUndo *mask_undo;
  1364.   TileManager *undo_tiles;
  1365.   PixelRegion srcPR, destPR;
  1366.   GImage *gimage;
  1367.  
  1368.   mask_undo = g_new (MaskUndo, 1);
  1369.   if (channel_bounds (mask, &x1, &y1, &x2, &y2))
  1370.     {
  1371.       undo_tiles = tile_manager_new ((x2 - x1), (y2 - y1), 1);
  1372.       pixel_region_init (&srcPR, GIMP_DRAWABLE (mask)->tiles,
  1373.              x1, y1, (x2 - x1), (y2 - y1), FALSE);
  1374.       pixel_region_init (&destPR, undo_tiles, 0, 0, (x2 - x1), (y2 - y1), TRUE);
  1375.       copy_region (&srcPR, &destPR);
  1376.     }
  1377.   else
  1378.     undo_tiles = NULL;
  1379.  
  1380.   mask_undo->tiles = undo_tiles;
  1381.   mask_undo->x     = x1;
  1382.   mask_undo->y     = y1;
  1383.  
  1384.   /* push the undo buffer onto the undo stack */
  1385.   gimage = GIMP_DRAWABLE (mask)->gimage;
  1386.   undo_push_mask (gimage, mask_undo);
  1387.   gimage_mask_invalidate (gimage);
  1388.  
  1389.   /*  invalidate the preview  */
  1390.   GIMP_DRAWABLE (mask)->preview_valid = FALSE;
  1391. }
  1392.  
  1393. void
  1394. channel_clear (Channel *mask)
  1395. {
  1396.   PixelRegion maskPR;
  1397.   guchar bg = 0;
  1398.  
  1399.   /*  push the current channel onto the undo stack  */
  1400.   channel_push_undo (mask);
  1401.  
  1402.   if (mask->bounds_known && !mask->empty)
  1403.     {
  1404.       pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  1405.              mask->x1, mask->y1,
  1406.              (mask->x2 - mask->x1), (mask->y2 - mask->y1), TRUE);
  1407.       color_region (&maskPR, &bg);
  1408.     }
  1409.   else
  1410.     {
  1411.       /*  clear the mask  */
  1412.       pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  1413.              0, 0,
  1414.              GIMP_DRAWABLE (mask)->width,
  1415.              GIMP_DRAWABLE (mask)->height, TRUE);
  1416.       color_region (&maskPR, &bg);
  1417.     }
  1418.  
  1419.   /*  we know the bounds  */
  1420.   mask->bounds_known = TRUE;
  1421.   mask->empty        = TRUE;
  1422.   mask->x1           = 0;
  1423.   mask->y1           = 0;
  1424.   mask->x2           = GIMP_DRAWABLE (mask)->width;
  1425.   mask->y2           = GIMP_DRAWABLE (mask)->height;
  1426. }
  1427.  
  1428. void
  1429. channel_invert (Channel *mask)
  1430. {
  1431.   PixelRegion maskPR;
  1432.   GimpLut *lut;
  1433.  
  1434.   /*  push the current channel onto the undo stack  */
  1435.   channel_push_undo (mask);
  1436.  
  1437.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  1438.              0, 0,
  1439.              GIMP_DRAWABLE (mask)->width,
  1440.              GIMP_DRAWABLE (mask)->height, TRUE);
  1441.   
  1442.   lut = invert_lut_new (1);
  1443.  
  1444.   pixel_regions_process_parallel ((p_func) gimp_lut_process_inline,
  1445.                   lut, 1, &maskPR);
  1446.   gimp_lut_free (lut);
  1447.   mask->bounds_known = FALSE;
  1448. }
  1449.  
  1450. void
  1451. channel_sharpen (Channel *mask)
  1452. {
  1453.   PixelRegion maskPR;
  1454.   GimpLut *lut;
  1455.  
  1456.   /*  push the current channel onto the undo stack  */
  1457.   channel_push_undo (mask);
  1458.  
  1459.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  1460.              0, 0,
  1461.              GIMP_DRAWABLE (mask)->width,
  1462.              GIMP_DRAWABLE (mask)->height, TRUE);
  1463.   lut = threshold_lut_new (0.5, 1);
  1464.  
  1465.   pixel_regions_process_parallel ((p_func) gimp_lut_process_inline,
  1466.                   lut, 1, &maskPR);
  1467.   gimp_lut_free (lut);
  1468.  
  1469.   mask->bounds_known = FALSE;
  1470. }
  1471.  
  1472. void
  1473. channel_all (Channel *mask)
  1474. {
  1475.   PixelRegion maskPR;
  1476.   guchar bg = 255;
  1477.  
  1478.   /*  push the current channel onto the undo stack  */
  1479.   channel_push_undo (mask);
  1480.  
  1481.   /*  clear the mask  */
  1482.   pixel_region_init (&maskPR, GIMP_DRAWABLE (mask)->tiles,
  1483.              0, 0,
  1484.              GIMP_DRAWABLE (mask)->width,
  1485.              GIMP_DRAWABLE (mask)->height, TRUE);
  1486.   color_region (&maskPR, &bg);
  1487.  
  1488.   /*  we know the bounds  */
  1489.   mask->bounds_known = TRUE;
  1490.   mask->empty        = FALSE;
  1491.   mask->x1           = 0;
  1492.   mask->y1           = 0;
  1493.   mask->x2           = GIMP_DRAWABLE (mask)->width;
  1494.   mask->y2           = GIMP_DRAWABLE (mask)->height;
  1495. }
  1496.  
  1497. void
  1498. channel_border (Channel *mask,
  1499.         gint     radius_x,
  1500.         gint     radius_y)
  1501. {
  1502.   PixelRegion bPR;
  1503.   gint x1, y1, x2, y2;
  1504.  
  1505.   if (radius_x < 0 || radius_y < 0)
  1506.     return;
  1507.  
  1508.   if (! channel_bounds (mask, &x1, &y1, &x2, &y2))
  1509.     return;
  1510.   if (channel_is_empty (mask))
  1511.     return;
  1512.  
  1513.   if (x1 - radius_x < 0)
  1514.     x1 = 0;
  1515.   else
  1516.     x1 -= radius_x;
  1517.   if (x2 + radius_x > GIMP_DRAWABLE (mask)->width)
  1518.     x2 = GIMP_DRAWABLE (mask)->width;
  1519.   else
  1520.     x2 += radius_x;
  1521.  
  1522.   if (y1 - radius_y < 0)
  1523.     y1 = 0;
  1524.   else
  1525.     y1 -= radius_y;
  1526.   if (y2 + radius_y > GIMP_DRAWABLE (mask)->height)
  1527.     y2 = GIMP_DRAWABLE (mask)->height;
  1528.   else
  1529.     y2 += radius_y;
  1530.   /*  push the current channel onto the undo stack  */
  1531.   channel_push_undo (mask);
  1532.  
  1533.   pixel_region_init (&bPR, GIMP_DRAWABLE (mask)->tiles, x1, y1,
  1534.              (x2-x1), (y2-y1), TRUE);
  1535.  
  1536.   border_region (&bPR, radius_x, radius_y);
  1537.  
  1538.   mask->bounds_known = FALSE;
  1539. }
  1540.  
  1541. void
  1542. channel_grow (Channel *mask,
  1543.           gint     radius_x,
  1544.           gint     radius_y)
  1545. {
  1546.   PixelRegion bPR;
  1547.   gint x1, y1, x2, y2;
  1548.  
  1549.   if (radius_x == 0 && radius_y == 0)
  1550.     return;
  1551.  
  1552.   if (radius_x <= 0 && radius_y <= 0)
  1553.     {
  1554.       channel_shrink (mask, -radius_x, -radius_y, FALSE);
  1555.       return;
  1556.     }
  1557.  
  1558.   if (radius_x < 0 || radius_y < 0)
  1559.     return;
  1560.   
  1561.   if (! channel_bounds (mask, &x1, &y1, &x2, &y2))
  1562.     return;
  1563.   if (channel_is_empty (mask))
  1564.     return;
  1565.  
  1566.   if (x1 - radius_x > 0)
  1567.     x1 = x1 - radius_x;
  1568.   else
  1569.     x1 = 0;
  1570.   if (y1 - radius_y > 0)
  1571.     y1 = y1 - radius_y;
  1572.   else
  1573.     y1 = 0;
  1574.   if (x2 + radius_x < GIMP_DRAWABLE (mask)->width)
  1575.     x2 = x2 + radius_x;
  1576.   else
  1577.     x2 = GIMP_DRAWABLE (mask)->width;
  1578.   if (y2 + radius_y < GIMP_DRAWABLE (mask)->height)
  1579.     y2 = y2 + radius_y;
  1580.   else
  1581.     y2 = GIMP_DRAWABLE (mask)->height;
  1582.  
  1583.   /*  push the current channel onto the undo stack  */
  1584.   channel_push_undo (mask);
  1585.  
  1586.   /*  need full extents for grow, not! */
  1587.   pixel_region_init (&bPR, GIMP_DRAWABLE (mask)->tiles, x1, y1, (x2 - x1),
  1588.              (y2 - y1), TRUE);
  1589.  
  1590.   fatten_region (&bPR, radius_x, radius_y);
  1591.  
  1592.   mask->bounds_known = FALSE;
  1593. }
  1594.  
  1595. void
  1596. channel_shrink (Channel  *mask,
  1597.         gint      radius_x,
  1598.         gint      radius_y,
  1599.         gboolean  edge_lock)
  1600. {
  1601.   PixelRegion bPR;
  1602.   gint x1, y1, x2, y2;
  1603.  
  1604.   if (radius_x == 0 && radius_y == 0)
  1605.     return;
  1606.  
  1607.   if (radius_x <= 0 && radius_y <= 0)
  1608.     {
  1609.       channel_grow (mask, -radius_x, -radius_y);
  1610.       return;
  1611.     }
  1612.  
  1613.   if (radius_x < 0 || radius_y < 0)
  1614.     return;
  1615.   
  1616.   if (! channel_bounds (mask, &x1, &y1, &x2, &y2))
  1617.     return;
  1618.   if (channel_is_empty (mask))
  1619.     return;
  1620.  
  1621.   if (x1 > 0)
  1622.     x1--;
  1623.   if (y1 > 0)
  1624.     y1--;
  1625.   if (x2 < GIMP_DRAWABLE (mask)->width)
  1626.     x2++;
  1627.   if (y2 < GIMP_DRAWABLE (mask)->height)
  1628.     y2++;
  1629.  
  1630.   /*  push the current channel onto the undo stack  */
  1631.   channel_push_undo (mask);
  1632.  
  1633.   pixel_region_init (&bPR, GIMP_DRAWABLE (mask)->tiles, x1, y1, (x2 - x1),
  1634.              (y2 - y1), TRUE);
  1635.  
  1636.   thin_region (&bPR, radius_x, radius_y, edge_lock);
  1637.  
  1638.   mask->bounds_known = FALSE;
  1639. }
  1640.  
  1641. void
  1642. channel_translate (Channel *mask,
  1643.            gint     off_x,
  1644.            gint     off_y)
  1645. {
  1646.   gint width, height;
  1647.   Channel *tmp_mask;
  1648.   PixelRegion srcPR, destPR;
  1649.   guchar empty = 0;
  1650.   gint   x1, y1, x2, y2;
  1651.  
  1652.   tmp_mask = NULL;
  1653.  
  1654.   /*  push the current channel onto the undo stack  */
  1655.   channel_push_undo (mask);
  1656.  
  1657.   channel_bounds (mask, &x1, &y1, &x2, &y2);
  1658.   x1 = CLAMP ((x1 + off_x), 0, GIMP_DRAWABLE (mask)->width);
  1659.   y1 = CLAMP ((y1 + off_y), 0, GIMP_DRAWABLE (mask)->height);
  1660.   x2 = CLAMP ((x2 + off_x), 0, GIMP_DRAWABLE (mask)->width);
  1661.   y2 = CLAMP ((y2 + off_y), 0, GIMP_DRAWABLE (mask)->height);
  1662.  
  1663.   width = x2 - x1;
  1664.   height = y2 - y1;
  1665.  
  1666.   /*  make sure width and height are non-zero  */
  1667.   if (width != 0 && height != 0)
  1668.     {
  1669.       /*  copy the portion of the mask we will keep to a
  1670.        *  temporary buffer
  1671.        */
  1672.       tmp_mask = channel_new_mask (GIMP_DRAWABLE (mask)->gimage, width, height);
  1673.  
  1674.       pixel_region_init (&srcPR, GIMP_DRAWABLE (mask)->tiles,
  1675.              x1 - off_x, y1 - off_y, width, height, FALSE);
  1676.       pixel_region_init (&destPR, GIMP_DRAWABLE (tmp_mask)->tiles,
  1677.              0, 0, width, height, TRUE);
  1678.       copy_region (&srcPR, &destPR);
  1679.     }
  1680.  
  1681.   /*  clear the mask  */
  1682.   pixel_region_init (&srcPR, GIMP_DRAWABLE (mask)->tiles,
  1683.              0, 0,
  1684.              GIMP_DRAWABLE (mask)->width,
  1685.              GIMP_DRAWABLE (mask)->height, TRUE);
  1686.   color_region (&srcPR, &empty);
  1687.  
  1688.   if (width != 0 && height != 0)
  1689.     {
  1690.       /*  copy the temp mask back to the mask  */
  1691.       pixel_region_init (&srcPR, GIMP_DRAWABLE (tmp_mask)->tiles,
  1692.              0, 0, width, height, FALSE);
  1693.       pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
  1694.              x1, y1, width, height, TRUE);
  1695.       copy_region (&srcPR, &destPR);
  1696.  
  1697.       /*  free the temporary mask  */
  1698.       channel_delete (tmp_mask);
  1699.     }
  1700.  
  1701.   /*  calculate new bounds  */
  1702.   if (width == 0 || height == 0)
  1703.     {
  1704.       mask->empty = TRUE;
  1705.       mask->x1 = 0; mask->y1 = 0;
  1706.       mask->x2 = GIMP_DRAWABLE (mask)->width;
  1707.       mask->y2 = GIMP_DRAWABLE (mask)->height;
  1708.     }
  1709.   else
  1710.     {
  1711.       mask->x1 = x1;
  1712.       mask->y1 = y1;
  1713.       mask->x2 = x2;
  1714.       mask->y2 = y2;
  1715.     }
  1716. }
  1717.  
  1718. void
  1719. channel_layer_alpha (Channel *mask,
  1720.              Layer   *layer)
  1721. {
  1722.   PixelRegion srcPR, destPR;
  1723.   guchar empty = 0;
  1724.   gint   x1, y1, x2, y2;
  1725.  
  1726.   /*  push the current mask onto the undo stack  */
  1727.   channel_push_undo (mask);
  1728.  
  1729.   /*  clear the mask  */
  1730.   pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
  1731.              0, 0,
  1732.              GIMP_DRAWABLE (mask)->width,
  1733.              GIMP_DRAWABLE (mask)->height, TRUE);
  1734.   color_region (&destPR, &empty);
  1735.  
  1736.   x1 = CLAMP (GIMP_DRAWABLE (layer)->offset_x, 0, GIMP_DRAWABLE (mask)->width);
  1737.   y1 = CLAMP (GIMP_DRAWABLE (layer)->offset_y, 0, GIMP_DRAWABLE (mask)->height);
  1738.   x2 = CLAMP (GIMP_DRAWABLE (layer)->offset_x + GIMP_DRAWABLE (layer)->width,
  1739.           0, GIMP_DRAWABLE (mask)->width);
  1740.   y2 = CLAMP (GIMP_DRAWABLE( layer)->offset_y + GIMP_DRAWABLE (layer)->height,
  1741.           0, GIMP_DRAWABLE (mask)->height);
  1742.  
  1743.   pixel_region_init (&srcPR, GIMP_DRAWABLE (layer)->tiles,
  1744.              (x1 - GIMP_DRAWABLE (layer)->offset_x),
  1745.              (y1 - GIMP_DRAWABLE (layer)->offset_y),
  1746.              (x2 - x1), (y2 - y1), FALSE);
  1747.   pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
  1748.              x1, y1, (x2 - x1), (y2 - y1), TRUE);
  1749.   extract_alpha_region (&srcPR, NULL, &destPR);
  1750.  
  1751.   mask->bounds_known = FALSE;
  1752. }
  1753.  
  1754. void
  1755. channel_load (Channel *mask,
  1756.           Channel *channel)
  1757. {
  1758.   PixelRegion srcPR, destPR;
  1759.  
  1760.   /*  push the current mask onto the undo stack  */
  1761.   channel_push_undo (mask);
  1762.  
  1763.   /*  copy the channel to the mask  */
  1764.   pixel_region_init (&srcPR, GIMP_DRAWABLE (channel)->tiles,
  1765.              0, 0,
  1766.              GIMP_DRAWABLE (channel)->width,
  1767.              GIMP_DRAWABLE (channel)->height, FALSE);
  1768.   pixel_region_init (&destPR, GIMP_DRAWABLE (mask)->tiles,
  1769.              0, 0,
  1770.              GIMP_DRAWABLE (channel)->width,
  1771.              GIMP_DRAWABLE (channel)->height, TRUE);
  1772.   copy_region (&srcPR, &destPR);
  1773.  
  1774.   mask->bounds_known = FALSE;
  1775. }
  1776.  
  1777. void
  1778. channel_invalidate_bounds (Channel *channel)
  1779. {
  1780.   channel->bounds_known = FALSE;
  1781. }
  1782.  
  1783.